//使用前说明
//在您将这个类导入的时候，是无法通过编译的，请先执行以下步骤。
//1.在使用前您可能需要在NuGet包管理器中安装Spire.Doc、Spire.xls、以及Sqlite。
////这关联了Word文档和Excel文档的操作代码，如果不需要，可不引用并删除相关方法
//2.在使用前您可能需要在“项目”菜单中选择“添加引用”添加“System.drawing”的引用
////这关联了Word文档中图片替换的代码，如果不需要，可不引用并删除相关方法
//3.在使用前您可能需要在“项目”菜单中选择“添加引用”添加“System.Management”的引用
////这是一些系统信息相关的代码，如果不需要，可不引用并删除相关方法
using System;
using System.Collections.Generic;
using System.Text;
using Spire.Doc;
using Spire.Doc.Fields;
using Spire.Xls;
using System.Diagnostics;
using System.IO;
using System.Text.RegularExpressions;
using System.Runtime.InteropServices;
using System.Threading;
using System.Globalization;
using System.Management;
using System.Net;
using System.Collections;
using System.Reflection;
using System.Data.OleDb;
using System.Data;
using System.Data.SQLite;

namespace 快编.调用
{
    class 调用
    {

        public CookieContainer cookies = new CookieContainer();
        private const string CategoryName = "Processor";
        private const string CounterName = "% Processor Time";
        private const string InstanceName = "_Total";

        [DllImport("kernel32")]
        private static extern int GetPrivateProfileString(string lpAppName, string lpKeyName, string lpDefault, StringBuilder lpReturnedString, int nSize, string lpFileName);


        [DllImport("kernel32")]
        private static extern int WritePrivateProfileString(string lpApplicationName, string lpKeyName, string lpString, string lpFileName);


        /// <summary>
        /// 获取一个随机数
        /// </summary>
        /// <param name="最小值">
        /// 获取随机数的最小值
        /// </param>
        /// <param name="最大值">
        /// 获取随机数的最大值
        /// </param>
        /// <returns></returns>
        public int 取随机数(int 最小值, int 最大值)
        {
            Random 随机数 = new Random();
            int 随机数输出 = 随机数.Next(最小值, 最大值);
            return (随机数输出);
        }


        /// <summary>
        /// 取一段文本的随机一行并只输出这一行
        /// </summary>
        /// <param name="一段文本">原文本</param>
        /// <returns></returns>
        public string 取随机行文本(string 一段文本)
        {
            Random 随机数 = new Random();
            int 随机数字 = 随机数.Next(0, 取行数(一段文本) + 1);
            System.IO.StringReader 读取器 = new System.IO.StringReader(一段文本);
            for (int i = 1; i < 随机数字; i++)
            {
                读取器.ReadLine();
            }
            string 当前行 = 读取器.ReadLine();
            return 当前行;

        }

        /// <summary>
        /// 重新载入应用程序
        /// </summary>
        public void 重新载入()
        {
            string path = 取程序路径();//获取可执行文件路径
            Process.Start(path);//再次运行程序
            Environment.Exit(0);//关闭当前程序

        }

        /// <summary>
        /// 返回数字的绝对值（float类型）
        /// </summary>
        /// <param name="数值">原数字</param>
        /// <returns></returns>
        public float 取绝对值(float 数值)
        {

            return System.Math.Abs(数值);
        }


        /// <summary>
        /// 返回数字的绝对值（int类型）
        /// </summary>
        /// <param name="数值">原数字</param>
        /// <returns></returns>
        public int 取绝对值(int 数值)
        {

            return System.Math.Abs(数值);
        }
        /// <summary>
        /// 返回数字的绝对值（double类型）
        /// </summary>
        /// <param name="数值">原数字</param>
        /// <returns></returns>
        public double 取绝对值(double 数值)
        {

            return System.Math.Abs(数值);
        }



        /// <summary>
        /// 等待用户按键继续
        /// </summary>
        public void 等待按键()
        {
            Console.ReadKey();
        }

        /// <summary>
        /// 取一段文本的某一行并只输出这一行
        /// </summary>
        /// <param name="一段文本">原文本</param>
        /// <param name="行数">文本的行数</param>
        /// <returns></returns>
        public string 取行文本(string 一段文本, int 行数)
        {


            System.IO.StringReader 读取器 = new System.IO.StringReader(一段文本);
            for (int i = 1; i < 行数; i++)
            {
                读取器.ReadLine();
            }
            string 当前行 = 读取器.ReadLine();
            return 当前行;

        }

        /// <summary>
        /// 取文本到某一行，并输出到此为止的所有行
        /// </summary>
        /// <param name="一段文本">需要取出的文本</param>
        /// <param name="行数">需要取出的行数</param>
        /// <param name="取到行">（随意填写一个数）</param>
        /// <returns></returns>
        public string 取行文本(string 一段文本, int 行数, int 取到行)
        {

            string 当前行 = "";
            System.IO.StringReader 读取器 = new System.IO.StringReader(一段文本);
            for (int i = 1; i < 行数 + 1; i++)
            {
                当前行 += 读取器.ReadLine() + "\n";

            }

            return 当前行;

        }


        /// <summary>
        /// 获取一段文本的长度，无论英文还是中文都算作一个字符
        /// </summary>
        /// <param name="一段文本">这里需要载入或者输入一段文本</param>
        /// <returns></returns>
        /// 
        public int 取文本长度(string 一段文本)
        {

            int 文本长度 = 一段文本.Length;
            return (文本长度);

        }

        /// <summary>
        /// 取系统的基础信息
        /// </summary>
        /// <param name="信息类型">机器名:{0};操作系统:{1};系统文件夹:{2};语言:{3};.NET:{4};当前用户:{5}</param>
        /// <returns></returns>
        public string 取系统基础信息(int 信息类型)
        {

            string 文本 = "";
            switch (信息类型)
            {
                case 0:
                    文本 = Environment.MachineName.ToString();
                    break;

                case 1:
                    文本 = Environment.OSVersion.ToString();
                    break;
                case 2:
                    文本 = Environment.SystemDirectory.ToString();
                    break;
                case 3:
                    文本 = CultureInfo.InstalledUICulture.EnglishName.ToString();
                    break;
                case 4:
                    文本 = Environment.Version.ToString();
                    break;
                case 5:
                    文本 = Environment.UserName.ToString();
                    break;
            }

            return 文本;
        }

        /// <summary>
        /// 获得总物理内存的大小，单位 (Byte)，如果获取失败，返回 -1.
        /// </summary>
        /// <returns></returns>
        public  long 取总可用物理内存()
        {
            long capacity = 0;
            try
            {
                foreach (ManagementObject mo1 in new ManagementClass("Win32_PhysicalMemory").GetInstances())
                    capacity += long.Parse(mo1.Properties["Capacity"].Value.ToString());
            }
            catch (Exception ex)
            {
                capacity = -1;
                Console.WriteLine(ex.Message);
            }
            return capacity;
        }


        /// <summary>
        /// 获得已使用的物理内存的大小，单位 (Byte)，如果获取失败，返回 -1.
        /// </summary>
        /// <returns></returns>
        public  long 取已使用物理内存()
        {
            long capacity = 0;
            try
            {
                foreach (ManagementObject mo1 in new ManagementClass("Win32_PerfFormattedData_PerfOS_Memory").GetInstances())
                    capacity += long.Parse(mo1.Properties["AvailableBytes"].Value.ToString());
            }
            catch (Exception ex)
            {
                capacity = -1;
                Console.WriteLine(ex.Message);
            }
            return capacity;
        }

        /// <summary>
        /// 获取现在应用程序运行的路径
        /// </summary>
        /// <returns></returns>
        public string 取程序路径()
        {

            string 程序名称 = Process.GetCurrentProcess().MainModule.FileName;
            return (程序名称);

        }

        /// <summary>
        /// 获取用户当前登录的用户名
        /// </summary>
        /// <returns></returns>
        public string 取当前用户名()
        {

            string 用户名 = Environment.UserName;
            return (用户名);

        }

        /// <summary>
        /// 获取CPU代数量
        /// </summary>
        /// <param name="测量延迟">输入一个延迟，可能会更精准，单位为毫秒 </param>
        /// <returns></returns>
        public string 取CPU使用率(int 测量延迟)
        {
            PerformanceCounter 使用率 = new PerformanceCounter(CategoryName, CounterName, InstanceName);
            float cpuLoad = 0;
            for (int i = 1; i < 3; i++)
            {
                Thread.Sleep(测量延迟);
                cpuLoad = 使用率.NextValue();
            }
            return Math.Round(cpuLoad, 2).ToString();


        }
        public int 取当前处理器数()
        {

            return Environment.ProcessorCount;

        }


        /// <summary>
        /// 获取用户的计算机名
        /// </summary>
        /// <returns></returns>
        public string 取当前计算机名()
        {

            string 计算机名 = Environment.MachineName;
            return (计算机名);

        }

        /// <summary>
        /// 获取用户当前使用的操作系统版本号
        /// </summary>
        /// <returns></returns>
        public System.Version 取当前系统版本()
        {

            System.Version 系统版本 = Environment.Version;
            return (系统版本);

        }

        /// <summary>
        /// 在控制台显示一段文本内容
        /// </summary>
        /// <param name="显示内容">输入一段文本</param>
        public void 控制台显示(string 显示内容)
        {

            Console.WriteLine(显示内容);

        }
        /// <summary>
        /// 在控制台显示一段整数内容
        /// </summary>
        /// <param name="显示内容">输入一段文本</param>
        public void 控制台显示(int 显示内容)
        {

            Console.WriteLine(显示内容);

        }

        /// <summary>
        /// 修改控制台当前行内容
        /// </summary>
        /// <param name="显示内容">输入一段文本</param>
        public void 控制台修改行(string 显示内容)
        {

            Console.SetCursorPosition(0, 0);
            Console.WriteLine(显示内容);

        }

        /// <summary>
        /// 修改控制台当前行内容
        /// </summary>
        /// <param name="显示内容">输入一段文本</param>
        public void 控制台修改行(int 显示内容)
        {

            Console.SetCursorPosition(0, 0);
            Console.WriteLine(显示内容);

        }

        /// <summary>
        /// 修改控制台当前行内容
        /// </summary>
        /// <param name="显示内容">输入一段文本</param>
        public void 控制台修改行(double 显示内容)
        {

            Console.SetCursorPosition(0, 0);
            Console.WriteLine(显示内容);

        }

        /// <summary>
        /// 在控制台生成一个新行以表示进度或状态
        /// </summary>
        /// <param name="显示内容">输入一段文本</param>
        public void 控制台状态行(string 显示内容)
        {
            Console.WriteLine();
            Console.SetCursorPosition(0, 0);
            Console.WriteLine(显示内容);

        }

        /// <summary>
        /// 在控制台生成一个新行以表示进度或状态
        /// </summary>
        /// <param name="显示内容">输入一段文本</param>
        public void 控制台状态行(double 显示内容)
        {
            Console.WriteLine();
            Console.SetCursorPosition(0, 0);
            Console.WriteLine(显示内容);

        }

        /// <summary>
        /// 在控制台隐藏光标
        /// </summary>
        public void 控制台隐藏光标()
        {
            Console.CursorVisible = false;

        }
        /// <summary>
        /// 在控制台显示光标
        /// </summary>
        public void 控制台显示光标()
        {
            Console.CursorVisible = true;

        }

        /// <summary>
        /// 在控制台生成一个新行以表示进度或状态
        /// </summary>
        /// <param name="显示内容">输入一段文本</param>
        public void 控制台状态行(int 显示内容)
        {
            Console.WriteLine();
            Console.SetCursorPosition(0, 0);
            Console.WriteLine(显示内容);

        }

        /// <summary>
        /// 在控制台显示一段小数内容
        /// </summary>
        /// <param name="显示内容">输入一段文本</param>
        public void 控制台显示(double 显示内容)
        {

            Console.WriteLine(显示内容);

        }


        /// <summary>
        /// 在控制台显示一个简易的进度条
        /// </summary>
        /// <param name="前置语句">在进度条之前的显示内容</param>
        /// <param name="当前数">进度条当前数量</param>
        /// <param name="总数">进度条填满总需数量</param>
        /// <param name="分段数量">分段数量</param>
        /// <param name="是否新行处理">填“是”或“否”</param>
        public void 控制台进度条(string 前置语句, int 当前数, int 总数, int 分段数量, string 是否新行处理)
        {
            if (是否新行处理 == "是")
            {
                Console.WriteLine();
            }
            Console.SetCursorPosition(0, Console.CursorTop);
            string 左侧栏 = "[";
            string 右侧栏 = "]";
            string 未填 = "-";
            string 已填 = "*";
            double 进度 = Convert.ToDouble(当前数) / Convert.ToDouble(总数) * 100;
            Console.Write(前置语句 + 左侧栏);
            int 已完成分段数 = 当前数 / (总数 / 分段数量);
            for (int i = 1; i < 已完成分段数; i++)
            {

                Console.Write(已填);
                分段数量 -= 1;
            }

            for (int i = 1; i < 分段数量; i++)
            {

                Console.Write(未填);

            }
            Console.Write(右侧栏);
            Console.Write(" " + 进度 + "%");
            Console.SetCursorPosition(0, Console.CursorTop);


        }


        /// <summary>
        /// 在控制台显示一段小数内容
        /// </summary>
        /// <param name="显示内容">输入一段文本</param>
        public void 控制台显示(float 显示内容)
        {

            Console.WriteLine(显示内容);

        }
        /// <summary>
        /// 在控制台显示一段Bool内容
        /// </summary>
        /// <param name="显示内容">输入一段文本</param>
        public void 控制台显示(bool 显示内容)
        {

            Console.WriteLine(显示内容.ToString());

        }
        /// <summary>
        /// 输入一个文件的路径这个会返回这个文件的大小，单位为KB
        /// </summary>
        /// <param name="文件路径">输入一个文件的完整路径</param>
        /// <returns></returns>
        public String 取文件大小(string 文件路径)

        {

            System.IO.FileInfo fileInfo;
            fileInfo = new System.IO.FileInfo(文件路径);
            double 文件大小 = System.Math.Ceiling(fileInfo.Length / 1024.0);


            return 文件大小.ToString();
        }

        /// <summary>
        /// 在控制台等待一个用户输入内容
        /// </summary>
        /// <returns></returns>
        public String 取对话内容()

        {

            string 用户输入 = Console.ReadLine();
            return 用户输入;


        }

        public String 命令行运行(String 命令)

        {
            string strInput = 命令;
            Process p = new Process();
            //设置要启动的应用程序
            p.StartInfo.FileName = "cmd.exe";
            //是否使用操作系统shell启动
            p.StartInfo.UseShellExecute = false;
            // 接受来自调用程序的输入信息
            p.StartInfo.RedirectStandardInput = true;
            //输出信息
            p.StartInfo.RedirectStandardOutput = true;
            // 输出错误
            p.StartInfo.RedirectStandardError = true;
            //不显示程序窗口
            p.StartInfo.CreateNoWindow = true;
            //启动程序
            p.Start();

            //向cmd窗口发送输入信息
            p.StandardInput.WriteLine(strInput + "&exit");

            p.StandardInput.AutoFlush = true;

            //获取输出信息
            string strOuput = p.StandardOutput.ReadToEnd();
            //等待程序执行完退出进程
            p.WaitForExit();
            p.Close();

            return strOuput;




        }

        /// <summary>
        /// 使这个线程等待一段时间后再继续执行
        /// </summary>
        /// <param name="毫秒数">输入一个时间，单位为毫秒。</param>
        public void 延时(int 毫秒数)

        {
            Thread.Sleep(毫秒数);


        }

        /// <summary>
        /// 结束这个应用程序总过程
        /// </summary>
        /// <param name="退出代码">输入一个退出代码返回给系统</param>
        public void 结束处理(int 退出代码 = 0)

        {
            System.Environment.Exit(退出代码);


        }

        /// <summary>
        /// 返回现在的小时数
        /// </summary>
        /// <returns></returns>
        public int 小时()

        {
            int hour = DateTime.Now.Hour;
            return hour;


        }


        /// <summary>
        /// 返回现在的分钟数
        /// </summary>
        /// <returns></returns>
        /// 
        public int 分钟()

        {
            int Minute = DateTime.Now.Minute;
            return Minute;


        }


        /// <summary>
        /// 返回现在的秒钟数
        /// </summary>
        /// <returns></returns>
        public int 秒钟()

        {
            int Secound = DateTime.Now.Second;
            return Secound;


        }
        /// <summary>
        /// 返回当前系统的时间，如果不需要进行计算，您可能需要转换为String。
        /// </summary>
        /// <returns></returns>
        public System.DateTime 当前时间()

        {
            System.DateTime DateAndtime = DateTime.Now;
            return DateAndtime;


        }

        /// <summary>
        /// 返回今天是多少日
        /// </summary>
        /// <returns></returns>
        public int 当前日()

        {
            int a = DateTime.Now.Day;
            return a;


        }

        /// <summary>
        /// 返回这个月是多少月
        /// </summary>
        /// <returns></returns>
        public int 当前月()

        {
            int a = DateTime.Now.Month;
            return a;


        }




        /// <summary>
        /// 返回今年是多少年。
        /// </summary>
        /// <returns></returns>
        public int 当前年()

        {
            int a = DateTime.Now.Year;
            return a;


        }
        /// <summary>
        /// 返回今天的开始时间，如果不需要进行计算，您可能需要转换为String。
        /// </summary>
        /// <returns></returns>
        public System.DateTime 当前日期()

        {
            System.DateTime DateOFday = DateTime.Today;
            return DateOFday;


        }
        /// <summary>
        /// 获取当前是星期几
        /// </summary>
        /// <returns>无需参数</returns>
        public string 当前星期数()
        {
            string week;
            switch ((int)DateTime.Now.DayOfWeek)
            {
                case 0:
                    week = "星期日";
                    break;
                case 1:
                    week = "星期一";
                    break;
                case 2:
                    week = "星期二";
                    break;
                case 3:
                    week = "星期三";
                    break;
                case 4:
                    week = "星期四";
                    break;
                case 5:
                    week = "星期五";
                    break;
                default:
                    week = "星期六";
                    break;
            }
            return week;
        }

        public string 当前数转大写(int 数字)
        {
            string 转换 = "未知";
            switch (数字)
            {

                case 0:
                    转换 = "零";
                    break;
                case 1:
                    转换 = "一";
                    break;
                case 2:
                    转换 = "二";
                    break;
                case 3:
                    转换 = "三";
                    break;
                case 4:
                    转换 = "四";
                    break;
                case 5:
                    转换 = "五";
                    break;
                case 6:
                    转换 = "六";
                    break;
                case 7:
                    转换 = "七";
                    break;
                case 8:
                    转换 = "八";
                    break;
                case 9:
                    转换 = "九";
                    break;
                case 10:
                    转换 = "十";
                    break;
            }
            return 转换;
        }



        public long 取当前时间戳()
        {
            TimeSpan ts = DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0);
            return Convert.ToInt64(ts.TotalSeconds);
        }

        public long 取当日时间戳()
        {
            TimeSpan ts = DateTime.Now.Date - new DateTime(1970, 1, 1, 0, 0, 0, 0);
            return Convert.ToInt64(ts.TotalSeconds);
        }

        /// <summary>
        /// 时间戳转换成日期
        /// </summary>
        /// <param name="时间戳"></param>
        /// <returns></returns>
        [Obsolete]
        public DateTime 时间戳转时间(long 时间戳)
        {
            DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
            long lTime = ((long)时间戳 * 10000000);
            TimeSpan toNow = new TimeSpan(lTime);
            DateTime targetDt = dtStart.Add(toNow);
            return targetDt;
        }

        /// <summary>
        /// 向一个文件写入数据
        /// </summary>
        /// <param name="文件路径">输入写入文件的目标路径</param>
        /// <param name="写入内容">输入要向文件写入的内容</param>
        public void 写入文件(String 文件路径, string 写入内容)
        {
            FileStream fs = new FileStream(文件路径, FileMode.Create);
            //获得字节数组
            byte[] data = System.Text.Encoding.Default.GetBytes(写入内容);
            //开始写入
            fs.Write(data, 0, data.Length);
            //清空缓冲区、关闭流
            fs.Flush();
            fs.Close();
        }

        /// <summary>
        /// 向一个文件写入数据，高级模式
        /// </summary>
        /// <param name="文件名">输入写入文件的目标路径</param>
        /// <param name="文件内容">输入要向文件写入的内容</param>
        /// <param name="是否追加写入">是否是向文件追加内容</param>
        /// <param name="编码">应用一个编码进行写入</param>
        /// <returns></returns>
        public bool 写入文件(string 文件名, string 文件内容, bool 是否追加写入, Encoding 编码)
        {
            try
            {
                StreamWriter sw = new StreamWriter(文件名, 是否追加写入, 编码);
                sw.WriteLine(文件内容);
                sw.Close();
                return true;
            }
            catch { return false; }
        }
        

        private IEnumerable<string> 文件按行遍历器(string 文件路径)
        {
            string 当前行;
            using (var 读取器 = File.OpenText(文件路径))
            {
                while ((当前行 = 读取器.ReadLine()) != null)
                {
                    yield return 当前行;
                }

            }


        }

        /// <summary>
        /// 读入一个文本文件
        /// </summary>
        /// <param name="文件路径">填写文本文件的路径</param>
        /// <returns></returns>
        public string 读入文件(string 文件路径)
        {

            var 遍历内容 = 文件按行遍历器(文件路径);
            var 显示 = "";
            foreach (var 输出 in 遍历内容)
            {

                显示 = 显示 + 输出 + "\n";
            }

            return 显示;
        }

        /// <summary>
        /// 快速读取一个文本文档
        /// </summary>
        /// <param name="文件路径">输入文件的路径</param>
        /// <returns></returns>
        public string 读入文件_快速(string 文件路径)
        {

            return File.ReadAllText(文件路径);
        }


        /// <summary>
        /// 快速读取一个文本文档
        /// </summary>
        /// <param name="文件路径">输入文件的路径</param>
        /// <returns></returns>
        public string 读入文件_快速(string 文件路径, Encoding 编码)
        {
            return File.ReadAllText(文件路径, 编码);
        }


        /// <summary>
        /// 创建一个新文件夹，若文件夹本身已经存在，则不执行操作
        /// </summary>
        /// <param name="文件夹路径">输入要创建文件夹的路径</param>
        /// <returns></returns>
        public void 新建文件夹(string 文件夹路径)
        {
            System.IO.Directory.CreateDirectory(文件夹路径);
        }

        /// <summary>
        /// 创建一个新空白文件，若文件本身已经存在，则覆盖文件
        /// </summary>
        /// <param name="文件路径">输入要创建文件的路径</param>
        /// <returns></returns>
        public void 新建文件(string 文件路径)
        {
            File.Create(文件路径);
        }

        /// <summary>
        ///读取一个配置项，如果这个配置项中的值不存在返回一个默认值
        /// </summary>
        /// <param name="配置节名">配置节名</param>
        /// <param name="配置项名">配置项名</param>
        /// <param name="默认返回">如果这个配置项中的值不存在返回一个默认值</param>
        /// <param name="配置项文件">指定一个配置项的文件路径</param>
        /// <returns></returns>
        public string 读配置项(string 配置项文件, string 配置节名, string 配置项名, string 默认返回)
        {
            if (File.Exists(配置项文件))
            {
                StringBuilder temp = new StringBuilder(1024);
                GetPrivateProfileString(配置节名, 配置项名, 默认返回, temp, 1024, 配置项文件);
                return temp.ToString();
            }
            else
            {
                return 默认返回;
            }
        }

        /// <summary>
        /// 抽取一个配置项中的配置节，获取其中所有的配置项与其的值
        /// </summary>
        /// <param name="配置文件路径"></param>
        /// <param name="配置节名"></param>
        /// <returns></returns>
        public string 读配置项节文本(string 配置文件路径, string 配置节名)
        {
            string 一段文本 = 读入文件_快速(配置文件路径, Encoding.GetEncoding("gb2312"));
            string 正则表达式 = String.Format(@"\[{0}\]\s([\s\S]+?)\[", 配置节名);
            return 正则子匹配文本(一段文本, 正则表达式, 0, 0);


        }

        /// <summary>
        /// 读取xls或者xlsx表格中的文字信息
        /// </summary>
        /// <param name="文件名">输入要读取的文件位置</param>
        /// <param name="工作表数">输入是第几个工作表</param>
        /// <param name="行数">输入要读取的工作表行数</param>
        /// <param name="列数">输入要读取的工作表列数</param>
        /// <returns></returns>
        public string 读xls表格文字(string 文件名, int 工作表数, int 行数, int 列数)
        {
            //初始化类
            var 文件 = new Spire.Xls.Workbook();
            //设置文件
            文件.LoadFromFile(文件名);
            Spire.Xls.Worksheet sheet = 文件.Worksheets[0];
            //读取表格文件
            var 输出 = sheet.GetText(行数, 列数);




            return 输出;
        }

        /// <summary>
        /// 向xls或者xlsx表格文件写入一串整数
        /// </summary>
        /// <param name="文件名">输入要操作的文件名</param>
        /// <param name="工作表数">输入要操作的工作表的号</param>
        /// <param name="行数">输入要操作的行数</param>
        /// <param name="列数">输入要操作的列数</param>
        /// <param name="数字">输入要写入的数字</param>
        /// <returns></returns>
        public string 写xls表格(string 文件名, int 工作表数, int 行数, int 列数, int 数字)
        {
            //初始化类
            var 文件 = new Spire.Xls.Workbook();
            //设置文件
            文件.LoadFromFile(文件名);
            Spire.Xls.Worksheet 表 = 文件.Worksheets[工作表数];
            表.Range[3, 4].NumberValue = 数字;
            //储存回文件
            文件.SaveToFile(文件名);






            return "成功";
        }


        /// <summary>
        /// 向xls或者xlsx表格文件写入一串文字
        /// </summary>
        /// <param name="文件名">输入要操作的文件名</param>
        /// <param name="工作表数">输入要操作的工作表的号</param>
        /// <param name="行数">输入要操作的行数</param>
        /// <param name="列数">输入要操作的列数</param>
        /// <param name="文字">输入要写入的文字</param>
        /// <returns></returns>
        public string 写xls表格(string 文件名, int 工作表数, int 行数, int 列数, String 文字)
        {
            //初始化类
            var 文件 = new Spire.Xls.Workbook();
            //设置文件
            文件.LoadFromFile(文件名);
            Spire.Xls.Worksheet 表 = 文件.Worksheets[工作表数];
            表.Range[列数, 行数].Text = 文字;
            //储存回文件
            文件.SaveToFile(文件名);

            return "成功";
        }

        /// <summary>
        /// 向xls或者xlsx表格文件写入一个时间
        /// </summary>
        /// <param name="文件名">输入要操作的文件名</param>
        /// <param name="工作表数">输入要操作的工作表的号</param>
        /// <param name="行数">输入要操作的行数</param>
        /// <param name="列数">输入要操作的列数</param>
        /// <param name="时间">输入要写入的时间</param>
        /// <returns></returns>
        public string 写xls表格(string 文件名, int 工作表数, int 行数, int 列数, DateTime 时间)
        {
            //初始化类
            var 文件 = new Spire.Xls.Workbook();
            //设置文件
            文件.LoadFromFile(文件名);
            Spire.Xls.Worksheet 表 = 文件.Worksheets[工作表数];
            表.Range[3, 4].DateTimeValue = 时间;
            //储存回文件
            文件.SaveToFile(文件名);

            return "成功";
        }


        /// <summary>
        /// 向xls或者xlsx表格文件写入一串小数（长）
        /// </summary>
        /// <param name="文件名">输入要操作的文件名</param>
        /// <param name="工作表数">输入要操作的工作表的号</param>
        /// <param name="行数">输入要操作的行数</param>
        /// <param name="列数">输入要操作的列数</param>
        /// <param name="小数">输入要写入的小数</param>
        /// <returns></returns>
        public string 写xls表格(string 文件名, int 工作表数, int 行数, int 列数, Double 小数)
        {
            //初始化类
            var 文件 = new Spire.Xls.Workbook();
            //设置文件
            文件.LoadFromFile(文件名);
            Spire.Xls.Worksheet 表 = 文件.Worksheets[工作表数];
            表.Range[3, 4].NumberValue = 小数;
            //储存回文件
            文件.SaveToFile(文件名);

            return "成功";
        }

        /// <summary>
        /// 向xls或者xlsx表格文件写入一串小数
        /// </summary>
        /// <param name="文件名">输入要操作的文件名</param>
        /// <param name="工作表数">输入要操作的工作表的号</param>
        /// <param name="行数">输入要操作的行数</param>
        /// <param name="列数">输入要操作的列数</param>
        /// <param name="小数">输入要写入的小数</param>
        /// <returns></returns>
        public string 写xls表格(string 文件名, int 工作表数, int 行数, int 列数, float 小数)
        {
            //初始化类
            var 文件 = new Spire.Xls.Workbook();
            //设置文件
            文件.LoadFromFile(文件名);
            Spire.Xls.Worksheet 表 = 文件.Worksheets[工作表数];
            表.Range[3, 4].NumberValue = 小数;
            //储存回文件
            文件.SaveToFile(文件名);

            return "成功";
        }

        /// <summary>
        /// 读取xls或者xlsx表格中的数字信息
        /// </summary>
        /// <param name="文件名">输入要读取的文件位置</param>
        /// <param name="工作表数">输入是第几个工作表</param>
        /// <param name="行数">输入要读取的工作表行数</param>
        /// <param name="列数">输入要读取的工作表列数</param>
        /// <returns></returns>
        public double 读xls表格数字(string 文件名, int 工作表数, int 行数, int 列数)
        {
            //初始化类
            var 文件 = new Spire.Xls.Workbook();
            //设置文件
            文件.LoadFromFile(文件名);
            Spire.Xls.Worksheet sheet = 文件.Worksheets[0];
            //读取表格文件
            var 输出 = sheet.GetNumber(行数, 列数);



            return 输出;
        }




        public string 读doc文档(string 文件名)
        {
            //初始化类 并读入文件 
            var 读取器 = new Spire.Doc.Document(); 读取器.LoadFromFile(文件名);
            //使用读取器读取并返回文档的内容
            string 文档内容 = 读取器.GetText();
            return 文档内容;
        }

        public string doc文档替换(string 文件名, string 替换正则表达式, string 替换为内容, string 目标路径)
        {
            //初始化类 并读入文件 
            Regex cache = new Regex(替换正则表达式);
            Document 读取器 = new Document(文件名);
            读取器.LoadFromFile(文件名);

            读取器.Replace(cache, 替换为内容);
            //使用读取器读取并返回文档的内容
            读取器.SaveToFile(目标路径);
            return "替换完毕";
        }



        public string doc图片替换(string DOC文件路径, string 图片文件路径, string 替换文本, string 目标路径)
        {
            //初始化类
            Document 读取器 = new Document(DOC文件路径);
            //载入文件
            读取器.LoadFromFile(DOC文件路径);
            System.Drawing.Image 图片读取器 = System.Drawing.Image.FromFile(图片文件路径);
            //初始化替换数组
            Spire.Doc.Section sec = 读取器.Sections[0];
            //查找文档中的指定文本内容
            Spire.Doc.Documents.TextSelection[] selections = 读取器.FindAllString(替换文本, true, true);
            int index = 0;
            Spire.Doc.Fields.TextRange range = null;

            //遍历文档，移除文本内容，插入图片
            foreach (Spire.Doc.Documents.TextSelection selection in selections)
            {
                DocPicture pic = new DocPicture(读取器);
                pic.LoadImage(图片读取器);
                range = selection.GetAsOneRange();
                index = range.OwnerParagraph.ChildObjects.IndexOf(range);
                range.OwnerParagraph.ChildObjects.Insert(index, pic);
                range.OwnerParagraph.ChildObjects.Remove(range);
            }

            //保存文档
            读取器.SaveToFile(目标路径, Spire.Doc.FileFormat.Docx);



            return "替换完毕";
        }


        /// <summary>
        /// 写配置项，返回True或者Flase
        /// </summary>
        /// <param name="配置项路径">输入目标文件路径</param>
        /// <param name="配置节名">配置节名 [ ]内的文字</param>
        /// <param name="配置项名">配置项名 = 前的文字</param>
        /// <param name="值">配置值 = 后的文字</param>
        /// <returns></returns>
        public bool 写配置项(string 配置项路径, string 配置节名, string 配置项名, string 值)
        {
            var pat = System.IO.Path.GetDirectoryName(配置项路径);
            if (Directory.Exists(pat) == false)
            {
                Directory.CreateDirectory(pat);
            }
            if (File.Exists(配置项路径) == false)
            {
                File.Create(配置项路径).Close();
            }
            long OpStation = WritePrivateProfileString(配置节名, 配置项名, 值, 配置项路径);
            if (OpStation == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }


        /// <summary>
        /// 写配置项，返回True或者Flase
        /// </summary>
        /// <param name="配置项路径">输入目标文件路径</param>
        /// <param name="配置节名">配置节名 [ ]内的文字</param>
        /// <param name="配置项名">配置项名 = 前的文字</param>
        /// <param name="值">配置值 = 后的数字</param>
        /// <returns></returns>
        public bool 写配置项(string 配置项路径, string 配置节名, string 配置项名, int 值)
        {
            var pat = System.IO.Path.GetDirectoryName(配置项路径);
            if (Directory.Exists(pat) == false)
            {
                Directory.CreateDirectory(pat);
            }
            if (File.Exists(配置项路径) == false)
            {
                File.Create(配置项路径).Close();
            }
            long OpStation = WritePrivateProfileString(配置节名, 配置项名, Convert.ToString(值), 配置项路径);
            if (OpStation == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }


        /// <summary>
        /// 查找一段文本是否在另一段文本中。
        /// </summary>
        /// <param name="一段文本">输入原文本</param>
        /// <param name="要查找的文本">输入要查找的文本</param>
        /// <returns>返回该文本出现的次数</returns>
        public int 文本重复次数(string 一段文本, string 要查找的文本)

        {

            string ss = "";
            ss = 一段文本;
            string pat = @要查找的文本;//正则表达式（将你要匹配的字符串写成正则表达式）
            Regex r = new Regex(pat, RegexOptions.IgnoreCase);
            Match m = r.Match(ss);
            int matchCount = 0;
            while (m.Success)
            {
                ++matchCount;//次数累加
                Group g = m.Groups[1];

                m = m.NextMatch();
            }
            return matchCount;

        }

        /// <summary>
        /// 取那一段文本的总行数
        /// </summary>
        /// <param name="一段文本">输入一段文本</param>
        /// <param name="要查找的文本">输入要查找的文本</param>
        /// <returns></returns>
        public int 取行数(string 一段文本, string 要查找的文本 = "\n")

        {

            string ss = "";
            ss = 一段文本;
            string pat = @要查找的文本;//正则表达式（将你要匹配的字符串写成正则表达式）
            Regex r = new Regex(pat, RegexOptions.IgnoreCase);
            Match m = r.Match(ss);
            int matchCount = 0;
            while (m.Success)
            {
                ++matchCount;//次数累加
                Group g = m.Groups[1];

                m = m.NextMatch();
            }
            return matchCount + 1;

        }

        /// <summary>
        /// 正则匹配一段文本，并列出所有子匹配项目
        /// </summary>
        /// <param name="一段文本">输入一段原文本</param>
        /// <param name="取几行">输入要取的行数</param>
        /// <param name="要查找的文本">正则表达式</param>
        /// <returns></returns>
        /// 



        /// <summary>
        /// 去除文本首尾的空格
        /// </summary>
        /// <param name="一段文本">待去除的文本</param>
        /// <returns></returns>
        public string 去文本首尾空(string 一段文本)

        {

            一段文本 = 一段文本.Trim();
            return 一段文本;

        }
        /// <summary>
        /// 判断是不是一个不带数字的文本
        /// </summary>
        /// <param name="一段文本">输入原文本</param>
        /// <returns>返回一个bool类型值</returns>
        public bool 判定是否为文本(string 一段文本)

        {
            if (char.IsLetter(一段文本, 0))
            {

                return true;

            }
            if (char.IsWhiteSpace(一段文本, 0))
            {

                return true;

            }
            return false;
        }

        /// <summary>
        /// 取一个小数的四舍五入
        /// </summary>
        /// <param name="一个数">Double类型的小数</param>
        /// <param name="到第几位小数">四舍五入到第几位</param>
        /// <returns></returns>
        public double 四舍五入(double 一个数, int 到第几位小数)

        {
            double 输出 = Math.Round(一个数, 到第几位小数);
            return 输出;

        }



        /// <summary>
        /// 将一段文本替换为一段新文本
        /// </summary>
        /// <param name="一段文本">原来的文本</param>
        /// <param name="替换文本">待替换的文本</param>
        /// <param name="新文本">需要替换成的文本</param>
        /// <returns>替换后的文本</returns>
        public string 文本替换(string 一段文本, string 替换文本, String 新文本)

        {

            一段文本 = 一段文本.Replace(替换文本, 新文本);
            return 一段文本;

        }


        /// <summary>
        /// 在一段文本中查找另一段文本是否存在
        /// </summary>
        /// <param name="一段文本">原文本</param>
        /// <param name="查找文本">需要查找的文本</param>
        /// <returns>返回这段文本是否存在，bool类型</returns>
        public bool 文本是否存在(string 一段文本, string 查找文本)

        {

            bool 判断结果 = 一段文本.Contains(查找文本);
            return 判断结果;
        }

        /// <summary>
        /// 清理控制台的屏幕
        /// </summary>
        public void 控制台清屏()

        {

            Console.Clear();
        }
        /// <summary>
        /// 等待用户按键后继续
        /// </summary>
        public void 控制台按键后继续()

        {

            Console.ReadKey();
        }

        /// <summary>
        /// 返回正则符合正则表达式，并且匹配后的子文本项
        /// </summary>
        /// <param name="一段文本">原文本</param>
        /// <param name="正则表达式">正则表达式</param>
        /// <param name="匹配">匹配索引</param>
        /// <param name="子匹配">子匹配索引</param>
        /// <returns>返回0为匹配空</returns>
        public string 正则子匹配文本(string 一段文本, string 正则表达式, int 匹配, int 子匹配)

        {

            Regex 匹配器 = new Regex(正则表达式);
            var 匹配集 = 匹配器.Matches(一段文本);
            if (匹配集.Count == 0)
            { return "Error"; }
            return 匹配集[匹配].Groups[子匹配 + 1].Value;

        }

        /// <summary>
        /// 返回正则表达式的文本子匹配数量
        /// </summary>
        /// <param name="一段文本">输入一段文本</param>
        /// <param name="正则表达式">输入一个正则表达式</param>
        /// <returns></returns>
        public int 正则子匹配数量(string 一段文本, string 正则表达式, int 匹配)

        {

            Regex 匹配器 = new Regex(正则表达式);
            var 匹配集 = 匹配器.Matches(一段文本);
            return 匹配集[匹配].Groups.Count;


        }


        /// <summary>
        /// 返回正则通过正则匹配的文本
        /// </summary>
        /// <param name="一段文本">输入一段文本</param>
        /// <param name="正则表达式">输入一个正则表达式</param>
        /// <param name="匹配索引">正则匹配索引</param>
        /// <returns></returns>
        public string 正则匹配文本(string 一段文本, string 正则表达式, int 匹配索引)

        {
            //正则创建
            var a = Regex.Matches(一段文本, 正则表达式);
            //表示获取第一个正则匹配索引
            return a[匹配索引].ToString();
        }


        /// <summary>
        /// 返回正则匹配的数量（次数）
        /// </summary>
        /// <param name="一段文本">输入一段文本</param>
        /// <param name="正则表达式">输入一个正则表达式</param>
        /// <returns></returns>
        public int 正则匹配数量(string 一段文本, string 正则表达式)

        {
            //正则创建
            var a = Regex.Matches(一段文本, 正则表达式);
            //正则匹配数量
            return a.Count;

        }

        /// <summary>
        /// 复制一个文件到新的位置，返回是否已经复制完毕
        /// </summary>
        /// <param name="原文件路径">原来文件的路径位置</param>
        /// <param name="新文件路径">新文件的路径位置</param>
        /// <param name="如果存在相同的路径是否替换">如果存在相同的路径的时的操作</param>
        /// <returns></returns>
        public string 复制文件(string 原文件路径, string 新文件路径, bool 是否替换)

        {
            File.Copy(原文件路径, 新文件路径, 是否替换);//三个参数分别是源文件路径，存储路径，若存储路径有相同文件是否替换
            return "成功复制了文件";

        }

        /// <summary>
        /// 判断一个文件是否存在，返回“是”或者“否”
        /// </summary>
        /// <param name="文件路径"></param>
        /// <returns></returns>
        public string 文件是否存在(string 文件路径)
        {
            if (File.Exists(文件路径))
            {

                return "是";
            }
            else
            {
                return "否";
            }
        }

        /// <summary>
        /// 遍历目录下所有子文件夹（包含子目录）
        /// </summary>
        /// <param name="目标路径">填写要遍历的目录路径</param>
        /// <returns></returns>
        public List<string> 遍历目录下文件夹(string 目标路径)
        {

            List<string> 文件夹列表 = new List<string>(Directory.GetDirectories(目标路径, "*", System.IO.SearchOption.AllDirectories));
            return 文件夹列表;

        }

        /// <summary>
        /// 遍历目录下所有子文件(仅限当前目录)
        /// </summary>
        /// <param name="目标路径">填写要遍历的目录路径</param>
        /// <returns></returns>
        public FileInfo[] 遍历目录下所有文件(string 目标路径)
        {
            DirectoryInfo 查询器 = new DirectoryInfo(目标路径);
            FileInfo[] 文件名列表 = 查询器.GetFiles();
            return 文件名列表;

        }

        /// <summary>
        /// 获取某个盘符下的磁盘空间
        /// </summary>
        /// <param name="磁盘盘符">输入计算机中的一个盘符</param>
        /// <param name="量程">输入数据的量程，GB/MB/KB</param>
        /// <returns></returns>
        public  double 取磁盘剩余空间(string 磁盘盘符, string 量程)
        {
            long totalSize = 0;
            double 剩余空间 = 0;
            磁盘盘符 = 磁盘盘符 + ":\\";
            System.IO.DriveInfo[] drives = System.IO.DriveInfo.GetDrives();
            foreach (System.IO.DriveInfo drive in drives)
            {
                if (drive.Name == 磁盘盘符)
                {
                    totalSize = drive.TotalFreeSpace / (1024 * 1024);
                }
                剩余空间 = Convert.ToDouble(totalSize);

            }
            if (量程 == "GB")
            {
                return Math.Round(剩余空间 / 1024, 2);
            }
            if (量程 == "MB")
            {
                return 剩余空间;
            }
            if (量程 == "KB")
            {
                return 剩余空间 * 1024;
            }

            return -1;

        }

        /// <summary>
        /// 获取某个盘符下的总磁盘空间
        /// </summary>
        /// <param name="磁盘盘符">输入计算机中的一个盘符</param>
        /// <param name="量程">输入数据的量程，GB/MB/KB</param>
        /// <returns></returns>
        public  double 取磁盘总空间(string 磁盘盘符, string 量程)
        {
            long totalSize = 0;
            double 剩余空间 = 0;
            磁盘盘符 = 磁盘盘符 + ":\\";
            System.IO.DriveInfo[] drives = System.IO.DriveInfo.GetDrives();
            foreach (System.IO.DriveInfo drive in drives)
            {
                if (drive.Name == 磁盘盘符)
                {
                    totalSize = drive.TotalSize / (1024 * 1024);
                }
                剩余空间 = Convert.ToDouble(totalSize);

            }
            if (量程 == "GB")
            {
                return Math.Round(剩余空间 / 1024, 2);
            }
            if (量程 == "MB")
            {
                return 剩余空间;
            }
            if (量程 == "KB")
            {
                return 剩余空间 * 1024;
            }

            return -1;

        }

        /// <summary>
        /// 让本机PING一个IP地址，获取PING的信息。
        /// </summary>
        /// <param name="模式">1为获取文字“已连接”或“未连接” 2为获取延迟</param>
        /// <param name="IP地址">键入一个IP地址</param>
        /// <returns></returns>
        public string 取PING状态(int 模式, string IP地址)
        {

            System.Net.NetworkInformation.Ping ping = new System.Net.NetworkInformation.Ping();
            System.Net.NetworkInformation.PingReply ping回应 = ping.Send(IP地址);
            switch (模式)
            {
                case 1:

                    if (ping回应.Status == System.Net.NetworkInformation.IPStatus.Success)
                    {

                        return "已连接";
                    }
                    else
                    {
                        return ("未连接");
                    }


                case 2:
                    return ping回应.RoundtripTime.ToString();

            }
            return "未连接";
        }


        /// <summary>
        /// GET方法(自动维护cookie)
        /// </summary>
        public string Get请求(string url, string referer = "", int timeout = 2000, Encoding encode = null)
        {
            string dat;
            HttpWebResponse res = null;
            HttpWebRequest req = null;
            try
            {
                req = (HttpWebRequest)WebRequest.Create(url);
                req.CookieContainer = cookies;
                req.AllowAutoRedirect = false;
                req.Timeout = timeout;
                req.Referer = referer;
                req.UserAgent = "Mozilla/5.0 (Windows NT 10.0;%20WOW64; rv:47.0) Gecko/20100101 Firefox/47.0";
                res = (HttpWebResponse)req.GetResponse();
                cookies.Add(res.Cookies);
                dat = new StreamReader(res.GetResponseStream(), encode ?? Encoding.UTF8).ReadToEnd();
                res.Close();
                req.Abort();
            }
            catch
            {
                return null;
            }
            return dat;
        }

        /// <summary>
        /// Post方法(自动维护cookie)
        /// </summary>
        public  string Post请求(string url, string postdata, CookieContainer cookie = null, string referer = "", int timeout = 2000, Encoding encode = null)
        {
            string html = null;
            HttpWebRequest request;
            HttpWebResponse response;
            if (encode == null) encode = Encoding.UTF8;
            try
            {
                byte[] byteArray = encode.GetBytes(postdata); // 转化
                request = (HttpWebRequest)WebRequest.Create(new Uri(url));
                if (cookie == null) cookie = new CookieContainer();
                request.CookieContainer = cookie;
                request.UserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; SV1; .NET CLR 1.1.4322; InfoPath.1)";
                request.Method = "POST";
                request.Referer = referer;
                request.ContentType = "application/x-www-form-urlencoded";
                request.ContentLength = byteArray.Length;
                request.Timeout = timeout;
                Stream newStream = request.GetRequestStream();
                newStream.Write(byteArray, 0, byteArray.Length);    //写入参数
                newStream.Close();
                response = (HttpWebResponse)request.GetResponse();
                cookie.Add(response.Cookies);
                StreamReader str = new StreamReader(response.GetResponseStream(), encode);
                html = str.ReadToEnd();
            }
            catch
            {
                return "";
            }
            return html;
        }


        public  string Get请求JSON(string Url)
        {
            //System.GC.Collect();
            HttpWebRequest 请求器 = (HttpWebRequest)WebRequest.Create(Url);
            请求器.Proxy = null;
            请求器.KeepAlive = false;
            请求器.Method = "GET";
            请求器.ContentType = "application/json; charset=UTF-8";
            请求器.AutomaticDecompression = DecompressionMethods.GZip;

            HttpWebResponse response = (HttpWebResponse)请求器.GetResponse();
            Stream myResponseStream = response.GetResponseStream();
            StreamReader myStreamReader = new StreamReader(myResponseStream, Encoding.UTF8);
            string retString = myStreamReader.ReadToEnd();

            myStreamReader.Close();
            myResponseStream.Close();

            if (response != null)
            {
                response.Close();
            }
            if (请求器 != null)
            {
                请求器.Abort();
            }

            return retString;
        }

        public  string Post请求JSON(string 网址, string 请求数据, string Referer)
        {
            HttpWebRequest 访问器 = (HttpWebRequest)WebRequest.Create(网址);
            访问器.Method = "POST";
            访问器.Referer = Referer;
            byte[] bytes = Encoding.UTF8.GetBytes(请求数据);
            访问器.ContentType = "application/x-www-form-urlencoded";
            访问器.ContentLength = bytes.Length;
            Stream myResponseStream = 访问器.GetRequestStream();
            myResponseStream.Write(bytes, 0, bytes.Length);

            HttpWebResponse response = (HttpWebResponse)访问器.GetResponse();
            StreamReader myStreamReader = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
            string retString = myStreamReader.ReadToEnd();

            myStreamReader.Close();
            myResponseStream.Close();

            if (response != null)
            {
                response.Close();
            }
            if (访问器 != null)
            {
                访问器.Abort();
            }
            return retString;
        }


        public  ArrayList json解析(string JSON文本, string 键名)
        {
            ArrayList 输出集 = new ArrayList();

            Regex 匹配器 = new Regex(String.Format("\"{0}\":\"(.*?)\"", 键名));
            var 匹配集 = 匹配器.Matches(JSON文本);
            for (int i = 0; i < 匹配集.Count; i++)
            {
                输出集.Add(匹配集[i].Groups[1].Value);

            }
            return 输出集;

        }


        /// <summary>
        /// UTF8转换成GB2312
        /// </summary>
        /// <param name="text">要转换代文本</param>
        /// <returns></returns>
        public  string 编码_utf8转gb2312(string text)
        {
            //声明字符集   
            System.Text.Encoding utf8, gb2312;
            //utf8   
            utf8 = System.Text.Encoding.GetEncoding("utf-8");
            //gb2312   
            gb2312 = System.Text.Encoding.GetEncoding("gb2312");
            byte[] utf;
            utf = utf8.GetBytes(text);
            utf = System.Text.Encoding.Convert(utf8, gb2312, utf);
            //返回转换后的字符   
            return gb2312.GetString(utf);
        }

        /// <summary>
        /// 解压GZIP的数据
        /// </summary>
        /// <param name="bytes">传入加密数据</param>
        /// <param name="encoding">解压的编码格式</param>
        /// <returns></returns>
        public  string 解压GZIP(byte[] bytes, string encoding = "GB2312")
        {
            string result = string.Empty;
            using (MemoryStream ms = new MemoryStream(bytes))
            {
                using (System.IO.Compression.GZipStream decompressedStream = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Decompress))
                {
                    using (StreamReader sr = new StreamReader(decompressedStream, Encoding.GetEncoding(encoding)))
                    {
                        result = sr.ReadToEnd();
                    }
                }
            }
            return result;
        }

        /// <summary>
        /// 使用反射来执行一个方法，方法若成功执行，将返回"成功执行"，但使用此方法具有安全隐患，如果在方法内没有完善的 try catch 机制，可能会导致报错。
        /// 若该方法不存在，将返回"无此方法"。
        /// </summary>
        /// <param name="目标类">传入一个type类型，初始化此类型示例代码 “Type 目标类 = typeof(方法组类);”</param>
        /// <param name="方法名">要从目标类运行的方法名</param>
        /// <param name="参数">该方法需要的参数，请通过动态数组形式传送</param>
        /// <returns></returns>
        public string 反射_执行方法(Type 目标类, string 方法名, ArrayList 参数)
        {

            //初始化方法搜索器，根据传入的方法名在目标类中进行搜索
            MethodInfo 方法搜索器;
            try
            {
                方法搜索器 = 目标类.GetMethod(Console.ReadLine());
            }
            catch
            {
                return "无此方法";
            }
            //获取参数的数量
            int 参数数量 = 方法搜索器.GetParameters().Length;
            //将参数的动态数组类型转换为Object类型
            object[] 传入参数 = 参数.ToArray();
            if (传入参数.Length != 参数数量)
            {
                Console.WriteLine("传入的参数数量不正确，可能引发错误");
            }
            //实例化目标类，注意，之前只是检索，但没有实例化。
            object 实例化目标类 = Activator.CreateInstance(目标类);
            //利用已有数据运行该方法
            try
            {
                方法搜索器.Invoke(实例化目标类, 传入参数);
            }
            catch
            {
                return "无此方法";
            }
            return "成功执行";
        }

        /// <summary>
        /// 判断这个类中是否有这个方法，若有则返回“方法存在”，否则返回“无此方法”
        /// </summary>
        /// <param name="目标类">传入一个type类型，初始化此类型示例代码 “Type 目标类 = typeof(方法组类);”</param>
        /// <param name="方法名">要从目标类运行的方法名</param>
        /// <returns></returns>
        public string 反射_方法是否存在(Type 目标类, string 方法名)
        {
            //初始化方法搜索器，根据传入的方法名在目标类中进行搜索
            MethodInfo 方法搜索器;
            try
            {
                方法搜索器 = 目标类.GetMethod(Console.ReadLine());
            }
            catch
            {
                return "无此方法";
            }
            return "方法存在";
        }

        /// <summary>
        /// 从一个类中查找一个方法，若方法存在，返回其所需的变量数。若不存在，将返回-1
        /// </summary>
        /// <param name="目标类">传入一个type类型，初始化此类型示例代码 “Type 目标类 = typeof(方法组类);”</param>
        /// <param name="方法名">要从目标类运行的方法名</param>
        /// <returns></returns>
        public   int 反射_方法所需变量数(Type 目标类, string 方法名)
        {
            //初始化方法搜索器，根据传入的方法名在目标类中进行搜索
            MethodInfo 方法搜索器;
            try
            {
                方法搜索器 = 目标类.GetMethod(Console.ReadLine());
            }
            catch
            {
                return -1;
            }
            //获取参数的数量
            return 方法搜索器.GetParameters().Length;
        }

        /// <summary>
        /// 遍历一个类中的所有方法，返回动态数组类型
        /// </summary>
        /// <param name="目标类">传入一个type类型，初始化此类型示例代码 “Type 目标类 = typeof(方法组类);”</param>
        /// <returns></returns>
        public ArrayList 反射_遍历类中所有方法(Type 目标类)
        {
            ArrayList 方法组 = new ArrayList();

            foreach (MethodInfo m in 目标类.GetMethods())
            {
                方法组.Add(m.Name);
            }
            return 方法组;

        }


        /// <summary>
        /// 通过SQL语句读取数据库文件内容，返回一张结果表
        /// 结果表访问方式 结果表.Rows[行数][列名] 行数为int 列名为string 
        /// </summary>
        /// <param name="数据库文件路径">数据库文件的路径</param>
        /// <param name="链接字符串">数据库文件的链接码，请通过“项目”，“添加新数据源”获取，输入时请省略文件路径。</param>
        /// <param name="查询语句">要运行的SQL语句</param>
        /// <param name="是否关闭数据库">在运行完毕后是否要关闭数据库，填“是”或“否”</param>
        /// <returns></returns>
        public DataTable 数据库_读取(string 数据库文件路径, string 链接字符串, string 查询语句, string 是否关闭数据库)
        {
            /*配置数据库信息*/
            string 文件_数据库 = 数据库文件路径;
            //打开数据库并开始查询
            //建立连接器，指定查询文件
            OleDbConnection 数据库访问器 = new OleDbConnection(链接字符串 + 文件_数据库);
            //初始化查询语句
            OleDbCommand 查询最后一个交易 = new OleDbCommand(查询语句, 数据库访问器);
            //启动数据库连接，并启动一个新表
            数据库访问器.Open();
            DataTable 结果表 = new DataTable();
            //启动一个查询后的智能数据集
            OleDbDataAdapter 运行数据集 = new OleDbDataAdapter();
            //运行查询语句
            运行数据集.SelectCommand = 查询最后一个交易;
            //将运行结果放到刚才建立的新表中
            运行数据集.Fill(结果表);
            if (是否关闭数据库 == "是")
            {
                数据库访问器.Close();
            }
            return 结果表;
        }

        /// <summary>
        /// 将数据库_读取方法所生成的DataTable转换为ArrayList以便于访问
        /// </summary>
        /// <param name="结果表">传入一张结果表</param>
        /// <param name="列名">输入要写入数组的列</param>
        /// <returns></returns>
        public ArrayList 数据库_写入数组(DataTable 结果表, string 列名)
        {
            ArrayList 数组名 = new ArrayList();
            for (int i = 0; i < 结果表.Rows.Count; i++)
            {
                数组名.Add(结果表.Rows[i][列名]);

            }
            return 数组名;
        }

        /// <summary>
        /// 新建一个SQLite数据库文件，若成功则返回"完成"，否则返回"错误"
        /// </summary>
        /// <param name="要创建的文件">要创建的SQLite数据库文件位置</param>
        /// <returns></returns>
        public string SQLite新建数据库(string 要创建的文件)
        {
            try
            { 
            SQLiteConnection.CreateFile("要创建的文件");
            }
            catch
            {
                return "错误";
            }
            return "完成";

        }

        /// <summary>
        /// 查询SQLite数据库中的内容
        /// 结果表访问方式 结果表.Rows[行数][列名] 行数为int 列名为string 
        /// </summary>
        /// <param name="数据库文件">数据库的文件位置</param>
        /// <param name="SQL命令">要执行的查询SQL指令</param>
        /// <returns></returns>
        public DataTable SQLite查询数据(string 数据库文件 , string SQL命令)
        {

            SQLiteConnection 数据库连接 = new SQLiteConnection("Data Source=" + 数据库文件 + ";Version=3;");
            数据库连接.Open();
            SQLiteCommand 命令 = new SQLiteCommand(SQL命令, 数据库连接);
            SQLiteDataAdapter 结果集 = new SQLiteDataAdapter(命令);
            DataTable 结果表 = new DataTable();
            结果集.Fill(结果表);
            return 结果表;
            数据库连接.Close();

        }

        /// <summary>
        /// 对SQLite数据库执行命令，执行后返回影响的行数
        /// </summary>
        /// <param name="数据库文件">数据库文件位置</param>
        /// <param name="SQL命令">要执行的SQL指令</param>
        /// <returns></returns>
        public int SQLite执行命令(string 数据库文件, string SQL命令)
        {

            SQLiteConnection 数据库连接 = new SQLiteConnection("Data Source=" + 数据库文件 + ";Version=3;");
            数据库连接.Open();
            SQLiteCommand 命令 = new SQLiteCommand(SQL命令, 数据库连接);
            int 影响的行数 = 命令.ExecuteNonQuery();
            数据库连接.Close();
            命令.Dispose();
            return 影响的行数;
        }


        private string 日期生成器(string 格式化字符串)
        {

            DateTime 时间 = DateTime.Parse(格式化字符串);
            快编.调用.调用 调用 = new 快编.调用.调用();
            //判断是否为双休日
            int 当前星期数 = Convert.ToInt32(时间.DayOfWeek);
            int 本月天数 = DateTime.DaysInMonth(时间.Year, 时间.Month);
            DateTime 本月的第一日 = Convert.ToDateTime(时间.Year + @"/" + 时间.Month + @"/" + "1");
            ArrayList 工作日 = new ArrayList();
            ArrayList 双休日 = new ArrayList();
            ArrayList 工作日区间 = new ArrayList();
            int 工作日开始段指针 = 0;
            int 工作日结束段指针 = 0;
            //遍历本月的每一天，如果这一天是周一到周五就归类到工作日，如果这一天是周六或者是周日就归类到双休日。
            int 遍历次数 = 1;
            while (遍历次数 <= 本月天数)
            {
                if (Convert.ToInt32(本月的第一日.DayOfWeek) >= 1 && Convert.ToInt32(本月的第一日.DayOfWeek) <= 5)
                {
                    工作日.Add(本月的第一日);


                }
                else
                {
                    双休日.Add(本月的第一日);
                }

                本月的第一日 = 本月的第一日.AddDays(1);
                遍历次数++;

            }
            bool 是否是双休日 = true;

            //工作日区间生成
            DateTime 本次存储 = 时间;
            DateTime 上一存储 = 时间;
            int 次数 = 0;
            foreach (DateTime 临时 in 工作日)
            {
                //如果是第一次遍历就先加入区间的开始，然后进行下次循环
                if (次数 == 0 && Convert.ToInt32(临时.DayOfWeek) <= 5 && Convert.ToInt32(临时.DayOfWeek) > 0)
                {
                    //后处理，第一次将日期计算提前到该周的开始
                    DateTime 临时2 = 临时.AddDays(-(Convert.ToInt32(临时.DayOfWeek) - 1));
                    工作日区间.Add(临时2);
                    上一存储 = 临时;
                    次数++;
                    continue;
                }
                本次存储 = 临时;

                //遍历查看日期是否是周一和周五 是就储存
                if (Convert.ToInt32(本次存储.DayOfWeek) == 1 || Convert.ToInt32(临时.DayOfWeek) == 5)
                {
                    工作日区间.Add(本次存储);
                }
                if (本次存储.Day == 本月天数)
                {
                    //后处理，如果最后一天不是周五，则补时到下月至本周结束
                    DateTime 临时2 = 临时.AddDays(5 - (Convert.ToInt32(临时.DayOfWeek)));
                    工作日区间.Add(临时2);

                }
                上一存储 = 临时;
                次数++;





            }
            //工作日区间输出 

            int 工作日区间数 = 工作日区间.Count / 2;
            int 指针开始 = 0;
            int 指针结束 = 1;
            for (int i = 1; i < 工作日区间数; i++)
            {
                if (时间.Month * 100 + 时间.Day >= Convert.ToDateTime(工作日区间[指针开始]).Month * 100 + Convert.ToDateTime(工作日区间[指针开始]).Day && 时间.Month * 100 + 时间.Day <= Convert.ToDateTime(工作日区间[指针结束]).Month * 100 + Convert.ToDateTime(工作日区间[指针结束]).Day)
                {
                    工作日开始段指针 = 指针开始;
                    工作日结束段指针 = 指针结束;
                }
                指针开始 += 2;
                指针结束 += 2;
            }
            string 最终输出 = "";
            if (工作日区间[工作日开始段指针] != 工作日区间[工作日结束段指针])
            {
                string 日期文件夹名 = Convert.ToDateTime(工作日区间[工作日开始段指针]).ToString("yyyy.MM.dd" + " - " + Convert.ToDateTime(工作日区间[工作日结束段指针]).ToString("yyyy.MM.dd"));
                最终输出 = 日期文件夹名;
            }
            else
            {
                最终输出 = "-1";
            }

            return 最终输出;

        }



    }




}
